package com.by.log.example;

import com.by.log.LoggerFactory;
import com.by.log.Logger;
import com.by.log.filter.DistributedTraceFilter;

import java.util.HashMap;
import java.util.Map;

/**
 * 分布式追踪功能测试类
 */
public class TraceTest {
    private static final Logger log = LoggerFactory.getLogger(TraceTest.class);
    
    public static void main(String[] args) throws InterruptedException {
        System.out.println("开始测试分布式追踪功能...");
        
        // 模拟服务A调用服务B的场景
        testDistributedTracing();
        
        // 等待一段时间确保所有日志都被处理
        Thread.sleep(1000);
        
        System.out.println("关闭日志框架...");
        LoggerFactory.shutdown();
        System.out.println("测试完成。");
    }
    
    private static void testDistributedTracing() throws InterruptedException {
        System.out.println("=== 服务A处理请求 ===");
        
        // 开始处理请求，启动一个新的追踪
        Map<String, String> headers = new HashMap<>();
        DistributedTraceFilter.beforeInvoke(headers, "ServiceA", "processRequest");
        
        log.info("服务A开始处理请求");
        
        // 模拟业务逻辑
        Thread.sleep(100);
        
        // 调用服务B
        callServiceB();
        
        // 记录方法调用统计
        log.recordMethodCall(true, 300);
        
        log.info("服务A完成请求处理");
        
        // 清理追踪上下文
        DistributedTraceFilter.afterInvoke();
    }
    
    private static void callServiceB() throws InterruptedException {
        System.out.println("=== 服务B处理请求 ===");
        
        // 模拟RPC调用，传递追踪信息
        Map<String, String> headers = DistributedTraceFilter.getCurrentContextHeaders();
        DistributedTraceFilter.beforeInvoke(headers, "ServiceB", "handleRequest");
        
        log.info("服务B开始处理请求");
        
        // 模拟业务逻辑
        Thread.sleep(50);
        
        // 记录方法调用统计
        log.recordMethodCall(true, 100);
        
        log.info("服务B完成请求处理");
        
        // 清理追踪上下文
        DistributedTraceFilter.afterInvoke();
    }
}